//! 简化的 Map 抽象层演示
//! 
//! 展示 Rust 中如何实现类似 Java 的 Map interface 和工厂模式

use std::collections::HashMap;
use std::hash::Hash;

/// 通用 Map trait，类似 Java 的 Map interface
pub trait MapTrait<K, V> 
where 
    K: Eq + Hash + Clone,
    V: Clone,
{
    fn insert(&mut self, key: K, value: V) -> Option<V>;
    fn get(&self, key: &K) -> Option<&V>;
    fn remove(&mut self, key: &K) -> Option<V>;
    fn contains_key(&self, key: &K) -> bool;
    fn len(&self) -> usize;
    fn is_empty(&self) -> bool { self.len() == 0 }
    fn hasher_name(&self) -> &'static str;
}

/// 为标准 HashMap 实现 MapTrait
impl<K, V> MapTrait<K, V> for HashMap<K, V>
where
    K: Eq + Hash + Clone,
    V: Clone,
{
    fn insert(&mut self, key: K, value: V) -> Option<V> {
        HashMap::insert(self, key, value)
    }
    
    fn get(&self, key: &K) -> Option<&V> {
        HashMap::get(self, key)
    }
    
    fn remove(&mut self, key: &K) -> Option<V> {
        HashMap::remove(self, key)
    }
    
    fn contains_key(&self, key: &K) -> bool {
        HashMap::contains_key(self, key)
    }
    
    fn len(&self) -> usize {
        HashMap::len(self)
    }
    
    fn hasher_name(&self) -> &'static str {
        "SipHash (StandardLibrary)"
    }
}

/// Map 类型枚举
#[derive(Debug, Clone, Copy)]
pub enum MapType {
    StandardHashMap,
    // 注：实际项目中会包含 FxHashMap 和 AHashMap
}

/// Map 工厂，类似 Java 的工厂模式
pub struct MapFactory;

impl MapFactory {
    pub fn create_map<K, V>(map_type: MapType) -> Box<dyn MapTrait<K, V>>
    where
        K: Eq + Hash + Clone + 'static,
        V: Clone + 'static,
    {
        match map_type {
            MapType::StandardHashMap => Box::new(HashMap::<K, V>::new()),
            // 注：实际项目中会包含其他 Map 类型
        }
    }
}

/// 业务服务类，展示 Java 风格编程
pub struct DataService {
    cache: Box<dyn MapTrait<String, String>>,
    config: Box<dyn MapTrait<String, String>>,
}

impl DataService {
    pub fn new(cache_type: MapType, config_type: MapType) -> Self {
        Self {
            cache: MapFactory::create_map(cache_type),
            config: MapFactory::create_map(config_type),
        }
    }
    
    pub fn set_cache(&mut self, key: &str, value: &str) {
        self.cache.insert(key.to_string(), value.to_string());
    }
    
    pub fn get_cache(&self, key: &str) -> Option<&String> {
        self.cache.get(&key.to_string())
    }
    
    pub fn cache_info(&self) -> String {
        format!("Cache: {} ({} items)", 
               self.cache.hasher_name(), 
               self.cache.len())
    }
}

fn main() {
    println!("🎯 Rust Map 抽象层演示 - Java 风格接口编程");
    
    let separator = "=".repeat(60);
    println!("{}", separator);
    
    // 1. 基本 Map 抽象使用
    println!("\n📋 1. 基本 Map 抽象使用");
    
    let mut map = MapFactory::create_map::<String, i32>(MapType::StandardHashMap);
    println!("  创建 Map: {}", map.hasher_name());
    
    // 使用统一接口
    map.insert("key1".to_string(), 100);
    map.insert("key2".to_string(), 200);
    
    println!("  插入数据完成");
    println!("  查询 key1: {:?}", map.get(&"key1".to_string()));
    println!("  查询 key2: {:?}", map.get(&"key2".to_string()));
    println!("  Map 大小: {}", map.len());
    println!("  包含 key1: {}", map.contains_key(&"key1".to_string()));
    
    // 2. 工厂模式的优势
    println!("\n🏭 2. 工厂模式的优势");
    
    // 根据环境选择不同的实现
    fn create_for_environment(is_production: bool) -> Box<dyn MapTrait<String, String>> {
        if is_production {
            println!("  创建生产环境 Map");
            MapFactory::create_map(MapType::StandardHashMap)
        } else {
            println!("  创建开发环境 Map");
            MapFactory::create_map(MapType::StandardHashMap)
        }
    }
    
    let prod_map = create_for_environment(true);
    let dev_map = create_for_environment(false);
    
    println!("  生产环境 Map: {}", prod_map.hasher_name());
    println!("  开发环境 Map: {}", dev_map.hasher_name());
    
    // 3. Java 风格的业务服务
    println!("\n☕ 3. Java 风格的业务服务");
    
    let mut service = DataService::new(MapType::StandardHashMap, MapType::StandardHashMap);
    
    // 使用统一的接口
    service.set_cache("user:1", "Alice");
    service.set_cache("user:2", "Bob");
    
    println!("  {}", service.cache_info());
    println!("  缓存数据 user:1: {:?}", service.get_cache("user:1"));
    println!("  缓存数据 user:2: {:?}", service.get_cache("user:2"));
    
    // 4. 性能演示
    println!("\n⚡ 4. 性能演示");
    
    const TEST_SIZE: usize = 10_000;
    let mut perf_map = MapFactory::create_map::<String, i32>(MapType::StandardHashMap);
    
    let start = std::time::Instant::now();
    for i in 0..TEST_SIZE {
        perf_map.insert(format!("key_{}", i), i as i32);
    }
    let insert_time = start.elapsed();
    
    let start = std::time::Instant::now();
    for i in 0..TEST_SIZE {
        let _ = perf_map.get(&format!("key_{}", i));
    }
    let search_time = start.elapsed();
    
    println!("  {} ({}):", "SipHash", perf_map.hasher_name());
    println!("    插入 {} 条: {:?}", TEST_SIZE, insert_time);
    println!("    查找 {} 条: {:?}", TEST_SIZE, search_time);
    println!("    插入速率: {:.0} ops/秒", TEST_SIZE as f64 / insert_time.as_secs_f64());
    println!("    查找速率: {:.0} ops/秒", TEST_SIZE as f64 / search_time.as_secs_f64());
    
    println!("\n🎉 总结：Rust 支持 Java 风格的接口编程！");
    println!("✅ 已实现的优势：");
    println!("  - 统一的 Map 接口抽象");
    println!("  - 工厂模式降低耦合");
    println!("  - 类型安全的多态性");
    println!("  - 最小化替换成本");
    
    println!("\n🚀 在 Redis-rs2 项目中，我们扩展了这个概念：");
    println!("  - 支持 FxHashMap（高性能）");
    println!("  - 支持 AHashMap（现代平衡）");
    println!("  - 运行时热切换能力");
    println!("  - 场景化配置选择");
}